package dijkstra;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import javax.swing.JOptionPane;

/**
 *
 * @author luisfemm
 */
public class Dijkstra {

    int[][] matrizPesos;
    int a;
    int b;
    Lector lectorcito = new Lector();
    ArrayList test;
    ArrayList<String[]> listaDatos = new ArrayList<String[]>(1);
    //ArrayList<Integer> verticesUsables = new ArrayList<Integer>(1);
    ArrayList<Integer> caminos;
    int verticeInicial;
    int cantidadVertices;
    int verticeMenorDistancia;

    /**
     * @param arregloGrafo, este parámetro es una matriz que contiene en su
     * primera fila y columna los nombres de los vértices de forma que cada
     * nombre en la posición [0][j] = [j][0]
     * @param verticePartida, este parámetro hace referencia al vértice desde
     * donde se quiere partir
     * @param verticeLlegada, este parámetro hace referencia al vértice a donde
     * se quiere llegar recorriendo la menor distancia
     */
    public int[][] acomodarDatos() {

        listaDatos = new ArrayList<String[]>(1);
        listaDatos = lectorcito.leer("Grafo");

        matrizPesos = new int[Integer.parseInt(listaDatos.get(0)[0])][Integer.parseInt(listaDatos.get(0)[0])];

        for (int i = 1; i < listaDatos.size(); i++) {

            matrizPesos[Integer.parseInt(listaDatos.get(i)[0])][Integer.parseInt(listaDatos.get(i)[1])] = Integer.parseInt(listaDatos.get(i)[2]);
            matrizPesos[Integer.parseInt(listaDatos.get(i)[1])][Integer.parseInt(listaDatos.get(i)[0])] = Integer.parseInt(listaDatos.get(i)[2]);

        }

        cantidadVertices = Integer.parseInt(listaDatos.get(0)[0]);

        rellenarMatriz();

        return matrizPesos;
    }

    public void rellenarMatriz() {

        for (int i = 0; i < matrizPesos.length; i++) {

            for (int j = 0; j < matrizPesos.length; j++) {

                if (i == j || matrizPesos[i][j] != 0) {
                } else {
                    matrizPesos[i][j] = -1;
                    matrizPesos[j][i] = -1;
                }

            }

        }

    }

    public void reacomodarCaminos(int indice) {
        if (indice == 0) {
            caminos.add(0);
        }
        
        for (int j = indice; j < cantidadVertices; j++) {

            if (j != verticeInicial) {
                caminos.add(matrizPesos[verticeInicial][j]);
            }

        }

    }

    public void imprimirVector() {

        String datos = "";
        for (int i = 0; i < caminos.size(); i++) {
            
            datos+= caminos.get(i) + " ";
                        
        }
        
        System.out.println("Los caminos son" + verticeInicial);

    }

    public void algoritmoDijkstra() {

        verticeInicial = Integer.parseInt(JOptionPane.showInputDialog("Por favor digite el número del vértice desde donde partirá"));
        caminos = new ArrayList<Integer>(verticeInicial + 1);

        acomodarDatos();
        int indice = 0;

        do {
            reacomodarCaminos(indice);
            verticeInicial = 0;
            indice++;
            verticeInicial++;
        } while (indice < 4);
        
        imprimirVector();
    }

    public static void main(String[] args) {

        //Dijkstra funcion = new Dijkstra();
        //funcion.algoritmoDijkstra();
        String cadena = "Luisfe";
        
        
        InputStream streamcito = new InputStream() {

            @Override
            public int read() throws IOException {
                
                
                
                throw new UnsupportedOperationException("Not supported yet.");
            }
        };
        char [] stringarray;
        stringarray = cadena.toCharArray();
        char caracter = 'a';
        int ascii = (int) caracter;
        
        System.out.println("El cacracter en ascii es: " + ascii);

    }
}
